---------------------review------------------------------

1.模块化机制
    模块 包 框架
        index.js(模块)
        jQuery/commentjs(框架)

    1.node
        commentjs本身就是一个模块，需要下载安装
        1.导出：
            每一个模块都有一个module对象
            module.exports:对象
            module可省略 exports
                exports.a=10;
                exports.say=function(){}
                exports={
                    a:10;
                    say:function(){}
                    //会覆盖重写
                }
        2.导入：
            require("./index.js")
                var result = require("./index.js")
                result.a
                result.say()

                第三方框架 引进前先下载 下载后直接写名不用写路径
                    require("mysql")；
                    require("jquery")；
                        默认从当前路径的./node_modules中找
                        没找到就一直往外的./node_modules
                简写：
                    require("./jquery")
                        1.如果当前文件夹下只有一个jquery.js文件
                        引入jquery.js
                        2.如果当前文件夹下有一个jquery文件夹
                        引入jquery文件夹下的index.js 没有就报错
                        3.如果同时存在，默认引用jquery.js文件

    2.es6
        1.导出：
            export关键字
                export a; // 报错
                var a=10;
                export {a,b,c}
                export {a as aa}
                export default ——>function/object
                一个模块中只能到处一次default
        2.导入：
            import {a} from ''
            import {a as b} from ''
            import * as p from ''
            import a form ''



2.解构
    将比较复杂的对象拆分为比较简单的变量

    1.对象解构
        data:{
            data:[],
            data:{
                list:[]
            }
        }
        var user = data.data.list；
        es6:
            var obj={
                name:'',
                age:12,
                oo:{
                    key:''
                }
            }
        var {name,age,oo:{kay}}=obj;//同名解构
        var{name:n,age:a}=obj//更名结构
        var{name:n,age=10}={name:'',age:20mm}//赋予默认值

    2.数组解构
        var arr=[1,2,3,4];
        let [a,b,c,d]=arr;//完全解构
        let [,a,,]=arr//不完全解构
        let [,,,,a=10]=arr //赋予默认值
        var [a,...b]=arr //剩余项解构 a=1 b=[2,3,4]
        
        var arr = [1,2,[3,4],5]
        let [a,b,[c,d],e] = arr 
        let [a,b,[c],d,e] = arr //a=1,b=2,c=3 
        let [a,b,c] = arr //a=1,b=2,c=[3,4]

    3.字符串解构
        类数组对象
        1.数组
            let[a,b,c]="hello"//a='h' b='e' c='l'
        2.对象
            let {length(String.prototype的方法)}="hello"
    4.number/boolean
        只能通过对象的方向解构
            let{ number/Boolean.prototype的方法 }=10/true

3.扩展运算符
    var arr=[1,2,3,4];
    let [...b]=arr //将arr剩余项打包给b

    let[...arr]//将arr拆开放在该中括号中
    [...arr,6,7]

    [...arguments]=[] //类数组能转换数组 因此底层逻辑应该是for而不是forEach

4.对象扩展
        Object.is(a,b) 返回值为Boolean
                判断两个参数是否为同一个值 
                console.log(a==b)
                console.log(a===b)
                console.log(Object.is(a,b))
                    "10" 10 false
                    NaN  NaN true
            Object.assign()
            Object.setPrototypeOf()
            Object.getPrototypeOf()
            Object.keys()
            Object.values()
            Object.entries()
                返回所有属性名和属性值组成的数组
            简写形式
                es5:
                var name="lisi";
                var say=function(){}

                var obj={
                    name:name,
                    say:say
                }

                es6:
                    var name="lisi";
                    var say=function(){}

                    var obj={
                        name,//name:name
                        say,//say:say
                        age:20
                    }

5.数组扩展
            静态方法
            Array.form()
            Array.of()
            非静态方法
            Array.prototype.find(function(){},this)
                默认返回undefined
                查找满足条件的第一个元素

                默认没有返回值
                当写了return时，有返回值
            Array.prototype.findIndex()
            Array.prototype.include(kay)
                判断数组中是否包含key
                    返回值为boolean
                    包含-》true
            Array.prototype.fill(key,beginIndex,endIndex)
                填充数组元素
                当前方法修改原数组
                默认begin:开始位置 不写默认为0;
                end:结束位置 不写到数组末尾——length
                -----不包含结束位置----
                如果begin/end为负数，
                    begin :-3+length
                    end:-2+length
            Array.keys()
                返回一个包含所有下标的迭代器Iterator
                    node:
                    next():{
                        value:item
                        done:是否到末尾true/false
                    }
                    keys.next().value
            Array.values()
            Array.entries()
--------------------------
1.函数扩展
    1.参数
        1.可以给参数设置默认值 
          
            function say(a,b){
                console.log(a,b)
            }
            say(1,2);
            es5 
                1.var a,var b,
                2.1->arguments[0] 2->arguments[1]
                3.arguments[0]->a arguments[1]]->b

            es6:
                function(a=0,b=0){
                    1.var a=0,var b=0,
                    有实参进入重写
                    2.1->arguments[0] 2->arguments[1]
                    3.arguments[0]->a arguments[1]]->b
                }
                say(1,2)
        或者通过解构的方式设置形式参数
            function say({name,age}){
                console.log(name,age)
            }
            say({name:"lisi",age:20})
        2.rest参数
            类似于数组的剩余项解构
            function(...a){
                console.log(a)
            }
            say(1,2,3,4,5,6,7,8,9)
    
    2.箭头函数
        1. var say=a=>a 
            箭头左侧为形式参数 箭头右侧为返回值
            相当于写了
                function say(a){
                    return a
                }
        2.var say=(a,b)=>a 形式参数个数大于1左侧加（）
        /var say =()=a>a 没有形式参数箭头左侧加（）
            相当于写了
                function say(a，b){
                    return a+b
                }
        3.var say=()=>{
            //可写多行代码
            return
            }
            #当函数体内容比较多或者不想提供返回值需要给箭头右侧使用大括号{}
                相当于写了：
                    function（）{
                        console.log()
                        console.log()
                    }
                    say（）

        4.回调函数使用箭头函数
            <!-- Array.prototype.forEach=function(handler,this){
                if(){
                    handler.call(this,)
                }
            }
            arr.forEach(function(){}) -->
            arr.forEach((item,index,arr)=>{

            })
            ==
            arr.forEach(function(item,index,arr){
                console.log(item)
            })
    3.this
        es5中，this在函数调用时确定
        es5中，this在函数声明时确定
            箭头函数中没有this值，找父对象的this/上下文执行环境
            箭头函数不能作为构造函数使用   
            箭头函数使用call/apply修改this值时，第一个参数会被忽略
2.set
    1.特点：
        1.类似数组
        2.元素可以是任意数据类型，同一个值只能保存一次
    2.初始化 构造函数
        new Set();//创建空集合
        new Set(数组/类数组对象/iterator);
    3.方法
        Set.prototype.size
        Set.prototype.has(key)
        Set.prototype.clear()
        Set.prototype.delete()
        Set.prototype.keys()
        Set.prototype.values()
        Set.prototype.entries()
        Set.prototype.forEach()

3.Map
    1.特点
        1.类似对象
        2.属性名和属性值均可以为任意数据类型
        3.展现形式是键值对的表现形式
    2.初始化 构造函数
        new Map();
        new Map([[10,"hello"],[{},function],[true,10],])
    3.ApI
        Map.prototype.size
        Map.prototype.set(key,value)
        Map.prototype.get(key)
        Map.prototype.has(key)
        Map.prototype.clear()
        Map.prototype.delete()
        Map.prototype.keys()
        Map.prototype.values()
        Map.prototype.entries()
        Map.prototype.forEach()
4.Iterator (迭代器：给所有可以遍历的对象提供一个可迭代的接口)
    1.产生原因
        arr:for foreach while()
        obj:for in
        arguments:for
        set：
        map:
    es6:
        新的循环概念：
        for of ：只要具有iterator接口（具有symbol.iterator）的就可以使用for of循环
        for(var item of arr){
            item->每一个数组项
        }
    2.原生具有接口的对象
        keys/values/array/map/set/类数组对象
    3.遍历过程
        var arr=[1,2,3,4];
        arr.next().value(手动多次调用)
        for(var item of arr){
            item->arr.next().value
        }
            1.创建一个遍历对象
            2.第一次调用next()->{
                value:item,
                done:boolean
            }
            3.第二次调用next()->{
                value:item,
                done:boolean
            }
            4....第n次调用next()->{
                value:undefined,
                done:true
            }
    4.手动添加接口
        只要是包含symbol，iterator属性的结构都可以使用for...of..进行遍历

        obj={
            name:"lisi",
            age:20,
            gender:"female",
            [Symbol.iterator]:function(){
                return function{
                    next{
                        value:item,
                        done:true/false
                    }
                }
            }
        }